import UIKit

@available(iOS 2.0, *)
extension QKC where AA :CALayer {
    open func bounds_qk_s(_ bounds:  CGRect) -> QKC<AA,YY,ZZ, CGRect>{
		return link(next: bounds).then_QK { $0.value.bounds = bounds }
	}
    open func bounds_qk_g() -> QKC<AA,YY,ZZ, CGRect>{
		 self +^ self.value.bounds
	}

    open func position_qk_s(_ position:  CGPoint) -> QKC<AA,YY,ZZ, CGPoint>{
		return link(next: position).then_QK { $0.value.position = position }
	}
    open func position_qk_g() -> QKC<AA,YY,ZZ, CGPoint>{
		 self +^ self.value.position
	}

    open func zPosition_qk_s(_ zPosition:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: zPosition).then_QK { $0.value.zPosition = zPosition }
	}
    open func zPosition_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.zPosition
	}

    open func anchorPoint_qk_s(_ anchorPoint:  CGPoint) -> QKC<AA,YY,ZZ, CGPoint>{
		return link(next: anchorPoint).then_QK { $0.value.anchorPoint = anchorPoint }
	}
    open func anchorPoint_qk_g() -> QKC<AA,YY,ZZ, CGPoint>{
		 self +^ self.value.anchorPoint
	}

    open func anchorPointZ_qk_s(_ anchorPointZ:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: anchorPointZ).then_QK { $0.value.anchorPointZ = anchorPointZ }
	}
    open func anchorPointZ_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.anchorPointZ
	}

    open func transform_qk_s(_ transform:  CATransform3D) -> QKC<AA,YY,ZZ, CATransform3D>{
		return link(next: transform).then_QK { $0.value.transform = transform }
	}
    open func transform_qk_g() -> QKC<AA,YY,ZZ, CATransform3D>{
		 self +^ self.value.transform
	}

    open func frame_qk_s(_ frame:  CGRect) -> QKC<AA,YY,ZZ, CGRect>{
		return link(next: frame).then_QK { $0.value.frame = frame }
	}
    open func frame_qk_g() -> QKC<AA,YY,ZZ, CGRect>{
		 self +^ self.value.frame
	}

    open func isHidden_qk_s(_ isHidden:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: isHidden).then_QK { $0.value.isHidden = isHidden }
	}
    open func isHidden_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.isHidden
	}

    open func isDoubleSided_qk_s(_ isDoubleSided:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: isDoubleSided).then_QK { $0.value.isDoubleSided = isDoubleSided }
	}
    open func isDoubleSided_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.isDoubleSided
	}

    open func isGeometryFlipped_qk_s(_ isGeometryFlipped:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: isGeometryFlipped).then_QK { $0.value.isGeometryFlipped = isGeometryFlipped }
	}
    open func isGeometryFlipped_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.isGeometryFlipped
	}

    open func superlayer_qk_g() -> QKC<AA,YY,ZZ, CALayer? >{
		 self +^ self.value.superlayer
	}

    open func sublayers_qk_s(_ sublayers:  [CALayer]?) -> QKC<AA,YY,ZZ, [CALayer]?>{
		return link(next: sublayers).then_QK { $0.value.sublayers = sublayers }
	}
    open func sublayers_qk_g() -> QKC<AA,YY,ZZ, [CALayer]?>{
		 self +^ self.value.sublayers
	}

    open func sublayerTransform_qk_s(_ sublayerTransform:  CATransform3D) -> QKC<AA,YY,ZZ, CATransform3D>{
		return link(next: sublayerTransform).then_QK { $0.value.sublayerTransform = sublayerTransform }
	}
    open func sublayerTransform_qk_g() -> QKC<AA,YY,ZZ, CATransform3D>{
		 self +^ self.value.sublayerTransform
	}

    open func mask_qk_s(_ mask:  CALayer?) -> QKC<AA,YY,ZZ, CALayer?>{
		return link(next: mask).then_QK { $0.value.mask = mask }
	}
    open func mask_qk_g() -> QKC<AA,YY,ZZ, CALayer?>{
		 self +^ self.value.mask
	}

    open func masksToBounds_qk_s(_ masksToBounds:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: masksToBounds).then_QK { $0.value.masksToBounds = masksToBounds }
	}
    open func masksToBounds_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.masksToBounds
	}

    open func contents_qk_s(_ contents:  Any?) -> QKC<AA,YY,ZZ, Any?>{
		return link(next: contents).then_QK { $0.value.contents = contents }
	}
    open func contents_qk_g() -> QKC<AA,YY,ZZ, Any?>{
		 self +^ self.value.contents
	}

    open func contentsRect_qk_s(_ contentsRect:  CGRect) -> QKC<AA,YY,ZZ, CGRect>{
		return link(next: contentsRect).then_QK { $0.value.contentsRect = contentsRect }
	}
    open func contentsRect_qk_g() -> QKC<AA,YY,ZZ, CGRect>{
		 self +^ self.value.contentsRect
	}

    open func contentsGravity_qk_s(_ contentsGravity:  CALayerContentsGravity) -> QKC<AA,YY,ZZ, CALayerContentsGravity>{
        return link(next: contentsGravity).then_QK { $0.value.contentsGravity = contentsGravity as String }
	}
    open func contentsGravity_qk_g() -> QKC<AA,YY,ZZ, CALayerContentsGravity>{
        self +^ self.value.contentsGravity as CALayerContentsGravity
	}

    @available(iOS 4.0, *)
    open func contentsScale_qk_s(_ contentsScale:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: contentsScale).then_QK { $0.value.contentsScale = contentsScale }
	}
    @available(iOS 4.0, *)
    open func contentsScale_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.contentsScale
	}

    open func contentsCenter_qk_s(_ contentsCenter:  CGRect) -> QKC<AA,YY,ZZ, CGRect>{
		return link(next: contentsCenter).then_QK { $0.value.contentsCenter = contentsCenter }
	}
    open func contentsCenter_qk_g() -> QKC<AA,YY,ZZ, CGRect>{
		 self +^ self.value.contentsCenter
	}

    @available(iOS 10.0, *)
    open func contentsFormat_qk_s(_ contentsFormat:  CALayerContentsFormat) -> QKC<AA,YY,ZZ, CALayerContentsFormat>{
        return link(next: contentsFormat).then_QK { $0.value.contentsFormat = contentsFormat as String }
	}
    @available(iOS 10.0, *)
    open func contentsFormat_qk_g() -> QKC<AA,YY,ZZ, CALayerContentsFormat>{
        self +^ self.value.contentsFormat as CALayerContentsFormat
	}

    open func minificationFilter_qk_s(_ minificationFilter:  CALayerContentsFilter) -> QKC<AA,YY,ZZ, CALayerContentsFilter>{
        return link(next: minificationFilter).then_QK { $0.value.minificationFilter = minificationFilter as String }
	}
    open func minificationFilter_qk_g() -> QKC<AA,YY,ZZ, CALayerContentsFilter>{
        self +^ self.value.minificationFilter as CALayerContentsFilter
	}

    open func magnificationFilter_qk_s(_ magnificationFilter:  CALayerContentsFilter) -> QKC<AA,YY,ZZ, CALayerContentsFilter>{
        return link(next: magnificationFilter).then_QK { $0.value.magnificationFilter = magnificationFilter as String }
	}
    open func magnificationFilter_qk_g() -> QKC<AA,YY,ZZ, CALayerContentsFilter>{
        self +^ self.value.magnificationFilter as CALayerContentsFilter
	}

    open func minificationFilterBias_qk_s(_ minificationFilterBias:  Float) -> QKC<AA,YY,ZZ, Float>{
		return link(next: minificationFilterBias).then_QK { $0.value.minificationFilterBias = minificationFilterBias }
	}
    open func minificationFilterBias_qk_g() -> QKC<AA,YY,ZZ, Float>{
		 self +^ self.value.minificationFilterBias
	}

    open func isOpaque_qk_s(_ isOpaque:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: isOpaque).then_QK { $0.value.isOpaque = isOpaque }
	}
    open func isOpaque_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.isOpaque
	}

    open func needsDisplayOnBoundsChange_qk_s(_ needsDisplayOnBoundsChange:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: needsDisplayOnBoundsChange).then_QK { $0.value.needsDisplayOnBoundsChange = needsDisplayOnBoundsChange }
	}
    open func needsDisplayOnBoundsChange_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.needsDisplayOnBoundsChange
	}

    @available(iOS 6.0, *)
    open func drawsAsynchronously_qk_s(_ drawsAsynchronously:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: drawsAsynchronously).then_QK { $0.value.drawsAsynchronously = drawsAsynchronously }
	}
    @available(iOS 6.0, *)
    open func drawsAsynchronously_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.drawsAsynchronously
	}

    open func edgeAntialiasingMask_qk_s(_ edgeAntialiasingMask:  CAEdgeAntialiasingMask) -> QKC<AA,YY,ZZ, CAEdgeAntialiasingMask>{
		return link(next: edgeAntialiasingMask).then_QK { $0.value.edgeAntialiasingMask = edgeAntialiasingMask }
	}
    open func edgeAntialiasingMask_qk_g() -> QKC<AA,YY,ZZ, CAEdgeAntialiasingMask>{
		 self +^ self.value.edgeAntialiasingMask
	}

    @available(iOS 2.0, *)
    open func allowsEdgeAntialiasing_qk_s(_ allowsEdgeAntialiasing:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: allowsEdgeAntialiasing).then_QK { $0.value.allowsEdgeAntialiasing = allowsEdgeAntialiasing }
	}
    @available(iOS 2.0, *)
    open func allowsEdgeAntialiasing_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.allowsEdgeAntialiasing
	}

    open func backgroundColor_qk_s(_ backgroundColor:  CGColor?) -> QKC<AA,YY,ZZ, CGColor?>{
		return link(next: backgroundColor).then_QK { $0.value.backgroundColor = backgroundColor }
	}
    open func backgroundColor_qk_g() -> QKC<AA,YY,ZZ, CGColor?>{
		 self +^ self.value.backgroundColor
	}

    open func cornerRadius_qk_s(_ cornerRadius:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: cornerRadius).then_QK { $0.value.cornerRadius = cornerRadius }
	}
    open func cornerRadius_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.cornerRadius
	}

    @available(iOS 11.0, *)
    open func maskedCorners_qk_s(_ maskedCorners:  CACornerMask) -> QKC<AA,YY,ZZ, CACornerMask>{
		return link(next: maskedCorners).then_QK { $0.value.maskedCorners = maskedCorners }
	}
    @available(iOS 11.0, *)
    open func maskedCorners_qk_g() -> QKC<AA,YY,ZZ, CACornerMask>{
		 self +^ self.value.maskedCorners
	}

    @available(iOS 13.0, *)
    open func cornerCurve_qk_s(_ cornerCurve:  CALayerCornerCurve) -> QKC<AA,YY,ZZ, CALayerCornerCurve>{
		return link(next: cornerCurve).then_QK { $0.value.cornerCurve = cornerCurve }
	}
    @available(iOS 13.0, *)
    open func cornerCurve_qk_g() -> QKC<AA,YY,ZZ, CALayerCornerCurve>{
		 self +^ self.value.cornerCurve
	}

    open func borderWidth_qk_s(_ borderWidth:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: borderWidth).then_QK { $0.value.borderWidth = borderWidth }
	}
    open func borderWidth_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.borderWidth
	}

    open func borderColor_qk_s(_ borderColor:  CGColor?) -> QKC<AA,YY,ZZ, CGColor?>{
		return link(next: borderColor).then_QK { $0.value.borderColor = borderColor }
	}
    open func borderColor_qk_g() -> QKC<AA,YY,ZZ, CGColor?>{
		 self +^ self.value.borderColor
	}

    open func opacity_qk_s(_ opacity:  Float) -> QKC<AA,YY,ZZ, Float>{
		return link(next: opacity).then_QK { $0.value.opacity = opacity }
	}
    open func opacity_qk_g() -> QKC<AA,YY,ZZ, Float>{
		 self +^ self.value.opacity
	}

    @available(iOS 2.0, *)
    open func allowsGroupOpacity_qk_s(_ allowsGroupOpacity:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: allowsGroupOpacity).then_QK { $0.value.allowsGroupOpacity = allowsGroupOpacity }
	}
    @available(iOS 2.0, *)
    open func allowsGroupOpacity_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.allowsGroupOpacity
	}

    open func compositingFilter_qk_s(_ compositingFilter:  Any?) -> QKC<AA,YY,ZZ, Any?>{
		return link(next: compositingFilter).then_QK { $0.value.compositingFilter = compositingFilter }
	}
    open func compositingFilter_qk_g() -> QKC<AA,YY,ZZ, Any?>{
		 self +^ self.value.compositingFilter
	}

    open func filters_qk_s(_ filters:  [Any]?) -> QKC<AA,YY,ZZ, [Any]?>{
		return link(next: filters).then_QK { $0.value.filters = filters }
	}
    open func filters_qk_g() -> QKC<AA,YY,ZZ, [Any]?>{
		 self +^ self.value.filters
	}

    open func backgroundFilters_qk_s(_ backgroundFilters:  [Any]?) -> QKC<AA,YY,ZZ, [Any]?>{
		return link(next: backgroundFilters).then_QK { $0.value.backgroundFilters = backgroundFilters }
	}
    open func backgroundFilters_qk_g() -> QKC<AA,YY,ZZ, [Any]?>{
		 self +^ self.value.backgroundFilters
	}

    open func shouldRasterize_qk_s(_ shouldRasterize:  Bool) -> QKC<AA,YY,ZZ, Bool>{
		return link(next: shouldRasterize).then_QK { $0.value.shouldRasterize = shouldRasterize }
	}
    open func shouldRasterize_qk_g() -> QKC<AA,YY,ZZ, Bool>{
		 self +^ self.value.shouldRasterize
	}

    open func rasterizationScale_qk_s(_ rasterizationScale:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: rasterizationScale).then_QK { $0.value.rasterizationScale = rasterizationScale }
	}
    open func rasterizationScale_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.rasterizationScale
	}

    open func shadowColor_qk_s(_ shadowColor:  CGColor?) -> QKC<AA,YY,ZZ, CGColor?>{
		return link(next: shadowColor).then_QK { $0.value.shadowColor = shadowColor }
	}
    open func shadowColor_qk_g() -> QKC<AA,YY,ZZ, CGColor?>{
		 self +^ self.value.shadowColor
	}

    open func shadowOpacity_qk_s(_ shadowOpacity:  Float) -> QKC<AA,YY,ZZ, Float>{
		return link(next: shadowOpacity).then_QK { $0.value.shadowOpacity = shadowOpacity }
	}
    open func shadowOpacity_qk_g() -> QKC<AA,YY,ZZ, Float>{
		 self +^ self.value.shadowOpacity
	}

    open func shadowOffset_qk_s(_ shadowOffset:  CGSize) -> QKC<AA,YY,ZZ, CGSize>{
		return link(next: shadowOffset).then_QK { $0.value.shadowOffset = shadowOffset }
	}
    open func shadowOffset_qk_g() -> QKC<AA,YY,ZZ, CGSize>{
		 self +^ self.value.shadowOffset
	}

    open func shadowRadius_qk_s(_ shadowRadius:  CGFloat) -> QKC<AA,YY,ZZ, CGFloat>{
		return link(next: shadowRadius).then_QK { $0.value.shadowRadius = shadowRadius }
	}
    open func shadowRadius_qk_g() -> QKC<AA,YY,ZZ, CGFloat>{
		 self +^ self.value.shadowRadius
	}

    open func shadowPath_qk_s(_ shadowPath:  CGPath?) -> QKC<AA,YY,ZZ, CGPath?>{
		return link(next: shadowPath).then_QK { $0.value.shadowPath = shadowPath }
	}
    open func shadowPath_qk_g() -> QKC<AA,YY,ZZ, CGPath?>{
		 self +^ self.value.shadowPath
	}

    open func actions_qk_s(_ actions:  [String : CAAction]?) -> QKC<AA,YY,ZZ, [String : CAAction]?>{
		return link(next: actions).then_QK { $0.value.actions = actions }
	}
    open func actions_qk_g() -> QKC<AA,YY,ZZ, [String : CAAction]?>{
		 self +^ self.value.actions
	}

    open func name_qk_s(_ name:  String?) -> QKC<AA,YY,ZZ, String?>{
		return link(next: name).then_QK { $0.value.name = name }
	}
    open func name_qk_g() -> QKC<AA,YY,ZZ, String?>{
		 self +^ self.value.name
	}

     open func delegate_qk_s(_ delegate:  CALayerDelegate?) -> QKC<AA,YY,ZZ, CALayerDelegate?>{
		return link(next: delegate).then_QK { $0.value.delegate = delegate }
	}
     open func delegate_qk_g() -> QKC<AA,YY,ZZ, CALayerDelegate?>{
		 self +^ self.value.delegate
	}

    open func style_qk_s(_ style:  [AnyHashable : Any]?) -> QKC<AA,YY,ZZ, [AnyHashable : Any]?>{
		return link(next: style).then_QK { $0.value.style = style }
	}
    open func style_qk_g() -> QKC<AA,YY,ZZ, [AnyHashable : Any]?>{
		 self +^ self.value.style
	}

    open func presentation_qk_f() -> QKC<AA,YY,ZZ,CALayer?>{
		 self +^ self.value.presentation()
	}

    open func model_qk_f() -> QKC<AA,YY,ZZ,CALayer>{
		 self +^ self.value.model()
	}

    open func shouldArchiveValue_qk_f(forKey key: String) -> QKC<AA,YY,ZZ,Bool>{
		 self +^ self.value.shouldArchiveValue(forKey:key)
	}

    open func affineTransform_qk_f() -> QKC<AA,YY,ZZ,CGAffineTransform>{
		 self +^ self.value.affineTransform()
	}

    open func setAffineTransform_qk_f(_ m: CGAffineTransform) -> QKC<AA,YY,ZZ, CGAffineTransform>{
		 self +^ self.value.setAffineTransform(m) +^ m
	}

    open func contentsAreFlipped_qk_f() -> QKC<AA,YY,ZZ,Bool>{
		 self +^ self.value.contentsAreFlipped()
	}

    open func removeFromSuperlayer_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.removeFromSuperlayer()
	}

    open func addSublayer_qk_f(_ layer: CALayer) -> QKC<AA,YY,ZZ, CALayer>{
		 self +^ self.value.addSublayer(layer) +^ layer
	}

    open func insertSublayer_qk_f(_ layer: CALayer, at idx: UInt32) -> QKC<AA,YY,ZZ, CALayer>{
		 self +^ self.value.insertSublayer(layer, at:idx) +^ layer
	}

    open func insertSublayer_qk_f(_ layer: CALayer, below sibling: CALayer?) -> QKC<AA,YY,ZZ, CALayer>{
		 self +^ self.value.insertSublayer(layer, below:sibling) +^ layer
	}

    open func insertSublayer_qk_f(_ layer: CALayer, above sibling: CALayer?) -> QKC<AA,YY,ZZ, CALayer>{
		 self +^ self.value.insertSublayer(layer, above:sibling) +^ layer
	}

    open func replaceSublayer_qk_f(_ oldLayer: CALayer, with newLayer: CALayer) -> QKC<AA,YY,ZZ, CALayer>{
		 self +^ self.value.replaceSublayer(oldLayer, with:newLayer) +^ oldLayer
	}

    open func convert_qk_f(_ p: CGPoint, from l: CALayer?) -> QKC<AA,YY,ZZ,CGPoint>{
		 self +^ self.value.convert(p, from:l)
	}

    open func convert_qk_f(_ p: CGPoint, to l: CALayer?) -> QKC<AA,YY,ZZ,CGPoint>{
		 self +^ self.value.convert(p, to:l)
	}

    open func convert_qk_f(_ r: CGRect, from l: CALayer?) -> QKC<AA,YY,ZZ,CGRect>{
		 self +^ self.value.convert(r, from:l)
	}

    open func convert_qk_f(_ r: CGRect, to l: CALayer?) -> QKC<AA,YY,ZZ,CGRect>{
		 self +^ self.value.convert(r, to:l)
	}

    open func convertTime_qk_f(_ t: CFTimeInterval, from l: CALayer?) -> QKC<AA,YY,ZZ,CFTimeInterval>{
		 self +^ self.value.convertTime(t, from:l)
	}

    open func convertTime_qk_f(_ t: CFTimeInterval, to l: CALayer?) -> QKC<AA,YY,ZZ,CFTimeInterval>{
		 self +^ self.value.convertTime(t, to:l)
	}

    open func hitTest_qk_f(_ p: CGPoint) -> QKC<AA,YY,ZZ,CALayer?>{
		 self +^ self.value.hitTest(p)
	}

    open func contains_qk_f(_ p: CGPoint) -> QKC<AA,YY,ZZ,Bool>{
		 self +^ self.value.contains(p)
	}

    open func display_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.display()
	}

    open func setNeedsDisplay_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.setNeedsDisplay()
	}

    open func setNeedsDisplay_qk_f(_ r: CGRect) -> QKC<AA,YY,ZZ, CGRect>{
		 self +^ self.value.setNeedsDisplay(r) +^ r
	}

    open func needsDisplay_qk_f() -> QKC<AA,YY,ZZ,Bool>{
		 self +^ self.value.needsDisplay()
	}

    open func displayIfNeeded_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.displayIfNeeded()
	}

    open func draw_qk_f(in ctx: CGContext) -> QKC<AA,YY,ZZ, CGContext>{
		 self +^ self.value.draw(in:ctx) +^ ctx
	}

    open func render_qk_f(in ctx: CGContext) -> QKC<AA,YY,ZZ, CGContext>{
		 self +^ self.value.render(in:ctx) +^ ctx
	}

    open func preferredFrameSize_qk_f() -> QKC<AA,YY,ZZ,CGSize>{
		 self +^ self.value.preferredFrameSize()
	}

    open func setNeedsLayout_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.setNeedsLayout()
	}

    open func needsLayout_qk_f() -> QKC<AA,YY,ZZ,Bool>{
		 self +^ self.value.needsLayout()
	}

    open func layoutIfNeeded_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.layoutIfNeeded()
	}

    open func layoutSublayers_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.layoutSublayers()
	}

    open func action_qk_f(forKey event: String) -> QKC<AA,YY,ZZ,CAAction?>{
		 self +^ self.value.action(forKey:event)
	}

    open func add_qk_f(_ anim: CAAnimation, forKey key: String?) -> QKC<AA,YY,ZZ, CAAnimation>{
		 self +^ self.value.add(anim, forKey:key) +^ anim
	}

    open func removeAllAnimations_qk_f() -> QKC<AA,YY,ZZ,Void>{
		 self +^ self.value.removeAllAnimations()
	}

    open func removeAnimation_qk_f(forKey key: String) -> QKC<AA,YY,ZZ, String>{
		 self +^ self.value.removeAnimation(forKey:key) +^ key
	}

    open func animationKeys_qk_f() -> QKC<AA,YY,ZZ,[String]?>{
		 self +^ self.value.animationKeys()
	}

    open func animation_qk_f(forKey key: String) -> QKC<AA,YY,ZZ,CAAnimation?>{
		 self +^ self.value.animation(forKey:key)
	}

}

